import os
import gc
import torch
from torch import nn, optim
import pandas as pd
from skimage import io, transform, morphology
from skimage.morphology import binary_dilation, star
import numpy as np
import matplotlib.pyplot as plt
from torch.utils.data import Dataset, DataLoader
from torchvision import transforms, utils
import torch

from torch.optim import lr_scheduler as schd
from tqdm import tqdm
!pip install imagecodecs

Requirement already satisfied: imagecodecs in /usr/local/lib/python3.10/dist-packages (2023.9.18)
Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from imagecodecs) (1.23.5)

from google.colab import drive
drive.mount('/content/drive')

Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount("/content/drive", force_remount=True).

class DRIVE_Dataset(Dataset):

  def __init__(self, data_dir, train=True, input_transform=None, target_transform=None, weight=1):
    self.training = 'training'if train else 'test'
    self.data_dir = os.path.join(data_dir, self.training)

    self.input_dir=os.path.join(self.data_dir, 'input')
    self.input=sorted([os.path.join(self.input_dir, image) for image in os.listdir(self.input_dir)])

    self.target_dir=os.path.join(self.data_dir, 'target')
    self.target=sorted([os.path.join(self.target_dir, image) for image in os.listdir(self.target_dir)])

    assert len(self.input) == len(self.target)

    self.input_transform = input_transform
    self.target_transform = target_transform

    self.to_tensor = transforms.ToTensor()
    self.conv_mask = torch.ones((1, 1, 11, 11)) * (3/(11*11))
    self.blur = lambda x: torch.nn.functional.conv2d(input=x.unsqueeze(0), weight=self.conv_mask, stride=1, padding='same').squeeze(0)

    self.weight=weight
  def __len__(self):
    return len(self.input)

  def __getitem__(self, idx):
    with torch.no_grad():



      input_im = self.to_tensor(io.imread(self.input[idx]))
      target_im = self.to_tensor((io.imread(self.target[idx]))).type(torch.LongTensor).squeeze(0)
      weight_im = self.blur((target_im.clone().type(torch.FloatTensor).unsqueeze(0) * self.weight)).squeeze(0).clamp(max=self.weight, min=1)

      weight_im[target_im == 1] = self.weight

      if self.input_transform:
        input_im = self.input_transform(input_im)
      if self.target_transform:
        target_im = self.target_transform(target_im)

      return (input_im, target_im, weight_im)

train_data=DRIVE_Dataset('/content/drive/MyDrive/dataset/drive',weight=10.5853)
test_data=DRIVE_Dataset('/content/drive/MyDrive/dataset/drive',weight=10.5853,train=False)

if train_data.weight==1:
  weight=0
  total=0
  positive=1
  for (input, target, _) in tqdm(train_data):
        total+=target.shape[-1]*target.shape[-2]
        positive+=target.sum()

  weight=((total-positive)/positive)
  test_data.weight=train_data.weight=weight

target=train_data[1][1]
weight=train_data[1][2]
print(target.shape)
plt.subplot(1, 2, 1)
plt.imshow(target,cmap='gray')
plt.subplot(1, 2, 2)

plt.imshow(weight, cmap='gray', vmin=0)
weight.max()

torch.Size([584, 565])

tensor(10.5853)

import matplotlib.pyplot as plt
length=3
begin=3
visualization_range = np.random.choice(len(train_data), length)
example_data = torch.stack([train_data[i][0] for i in visualization_range])
example_targets = torch.stack([train_data[i][1] for i in visualization_range])
example_weights = torch.stack([train_data[i][2] for i in visualization_range])

fig = plt.figure()
print(example_data.shape)
for i in range(3):
  print(example_data[i].shape)

  data = example_data[i].movedim(0, 2)

  print(data.shape)
  plt.subplot(3,3,3*i+1)
  plt.tight_layout()
  plt.imshow(data)
  plt.xticks([])
  plt.yticks([])

  print(example_targets[i].shape)
  target = example_targets[i]

  print (target.shape)
  plt.subplot(3,3,3*i+2)
  plt.tight_layout()
  plt.imshow(target, cmap='gray')
  plt.xticks([])
  plt.yticks([])

  print(torch.unique(target))

  weight=example_weights[i]
  print (weight.shape)
  plt.subplot(3,3,3*i+2)
  plt.tight_layout()
  plt.imshow(weight, cmap='gray', )
  plt.xticks([])
  plt.yticks([])

torch.Size([3, 3, 584, 565])
torch.Size([3, 584, 565])
torch.Size([584, 565, 3])
torch.Size([584, 565])
torch.Size([584, 565])
tensor([0, 1])
torch.Size([584, 565])
torch.Size([3, 584, 565])
torch.Size([584, 565, 3])
torch.Size([584, 565])
torch.Size([584, 565])
tensor([0, 1])
torch.Size([584, 565])
torch.Size([3, 584, 565])
torch.Size([584, 565, 3])
torch.Size([584, 565])
torch.Size([584, 565])
tensor([0, 1])
torch.Size([584, 565])

def count_parameters(model):
    return sum(p.numel() for p in model.parameters() if p.requires_grad)

def train(network, train_loader, epoch, optimizer, loss_fn, log_interval, batch_size_train, train_losses, train_counter):
  network.train()
  for batch_idx, (data, target, weight) in enumerate(train_loader):
    gc.collect()
    torch.cuda.empty_cache()
    data = data.to(device)
    target = target.to(device)
    weight =  weight.to(device)

    optimizer.zero_grad()
    output = network(data)

    loss = loss_fn(output, target)
    loss = loss * weight

    loss = loss.mean()

    loss.backward()

    optimizer.step()

    data = None
    target = None
    weight = None
    gc.collect()
    torch.cuda.empty_cache()
    if batch_idx % log_interval == 0:
      print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
        epoch, batch_idx * batch_size_train, len(train_loader.dataset),
        100 * batch_idx / len(train_loader), loss))
    train_losses.append(loss)
    train_counter.append((batch_idx*batch_size_train) + ((epoch-1)*len(train_loader.dataset)))

def test(network, test_loader, loss_fn, batch_size_test, test_losses, test_counter):

  network.eval()
  test_loss = 0
  correct = 0
  batches=0
  total=0
  with torch.no_grad():
    for data, target, weight in test_loader:
      gc.collect()
      torch.cuda.empty_cache()
      data = data.to(device)
      target = target.to(device)
      weight = weight.to(device)
      output = network(data)
      loss = loss_fn(output, target ) * weight
      test_loss += loss.sum()
      pred = (output.argmax(dim=-3))
      correct += pred.eq(target).sum()
      total += target.numel()
  test_loss = test_loss / total
  test_losses.append(test_loss)
  test_counter.append((test_counter[-1] + len(test_loader.dataset))if len(test_counter) > 0 else 0)
  print('\nTest set: Avg. loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
    test_loss, correct, total,
    100 * correct / total ) )


  fig = plt.figure()
  ind = np.random.randint(0, len(test_loader.dataset))
  input=test_loader.dataset[ind][0]
  target=test_loader.dataset[ind][1]
  plt.subplot(1,3,1)
  plt.imshow(input.movedim(0, 2))
  plt.subplot(1,3,2)
  plt.imshow(target, cmap='gray')
  plt.subplot(1,3,3)
  output=network(input.unsqueeze(0).to(device)).cpu().squeeze(0).argmax(-3)
  plt.imshow(output, cmap='gray', vmin=0, vmax=1)
  plt.show()

class UNetBlock(nn.Module):

  def __init__(self, in_channels, out_channels):
    super().__init__()

    self.seq=nn.Sequential(
      nn.Conv2d(in_channels, out_channels, 3, padding='same'),
      nn.ReLU(),
      nn.BatchNorm2d(out_channels),
      nn.Conv2d(out_channels, out_channels, 3, padding='same'),
      nn.ReLU())

  def forward(self, x):
    return self.seq(x)

class UpConvBlock(nn.Module):
  def __init__(self, in_channels, out_channels):
    super().__init__()

    self.ct= nn.Sequential(
      nn.ConvTranspose2d(in_channels, out_channels, kernel_size=2, stride=2),
      nn.ReLU())


  def forward(self, x, i):
    o = self.ct(x)

    padding = [0, 0, 0, 0]
    if o.shape[-1] == (i.shape[-1] - 1):
      padding[0] = 1
    if o.shape[-2] == (i.shape[-2] - 1):
      padding[2] = 1

    o = torch.nn.functional.pad(o, padding, mode='replicate')

    return torch.cat([i, o], dim=1)

class UNet(nn.Module):
    def __init__(self):
        super(UNet, self).__init__()


        self.e1=UNetBlock(3, 64)
        self.me1=nn.MaxPool2d(2)


        self.bt=UNetBlock(64, 128)


        self.ct1=UpConvBlock(128, 64)
        self.d1=UNetBlock(128, 64)

        self.cls = nn.Sequential(
            nn.Conv2d(64, 2, kernel_size=1),
            nn.ReLU()
        )



    def forward(self, x):
        i1 = self.e1(x)

        b = self.bt(self.me1(i1))

        o1 = self.d1( self.ct1(b, i1) )

        cls = self.cls(o1)

        return cls

random_seed = 42
torch.manual_seed(random_seed)
device = 'cuda' if torch.cuda.is_available() else 'cpu'
parameters_file='/content/drive/MyDrive/modelos/segmentacao_vasos/parameters.pth'
saved_parameters_file='/content/drive/MyDrive/modelos/segmentacao_vasos/best_parameters.pth'
training_data_file='/content/drive/MyDrive/modelos/segmentacao_vasos/treinamento.pickle'
batch_size_train = 8
batch_size_test = 8
train_loader = torch.utils.data.DataLoader(
  train_data,
  batch_size=batch_size_train, shuffle=True)

test_loader = torch.utils.data.DataLoader(
  test_data,
  batch_size=batch_size_test, shuffle=True)
device

'cuda'

gc.collect()
torch.cuda.empty_cache()
n_epochs = 150

learning_rate = 1e-3

log_interval=1

network = UNet().to(device)

optimizer = optim.Adam(network.parameters(), lr=learning_rate)
loss_fn=nn.CrossEntropyLoss(reduction='none', )
scheduler = schd.StepLR(optimizer, 100, 0.5)

train_losses = []
train_counter = []
test_losses = []
test_counter=[]

count_parameters(network)

404354

test(network, test_loader, loss_fn, batch_size_test,  test_losses, test_counter)
best=test_losses[-1]
for epoch in range(1, n_epochs + 1):
  train(network, train_loader, epoch, optimizer, loss_fn, log_interval, batch_size_train, train_losses, train_counter)
  test(network, test_loader, loss_fn, batch_size_test,  test_losses, test_counter)
  if test_losses[-1] < best:
    best=test_losses[-1]
    print("New best! Saving...")
    torch.save(network.state_dict(), parameters_file)
  scheduler.step()

torch.save((train_counter, train_losses, test_losses), training_data_file)

Test set: Avg. loss: 2.0280, Accuracy: 6021255/6599200 (91%)

Train Epoch: 1 [0/20 (0%)]	Loss: 2.071117
Train Epoch: 1 [8/20 (33%)]	Loss: 1.858218
Train Epoch: 1 [16/20 (67%)]	Loss: 1.663678

Test set: Avg. loss: 2.0216, Accuracy: 6021255/6599200 (91%)

New best! Saving...
Train Epoch: 2 [0/20 (0%)]	Loss: 1.641148
Train Epoch: 2 [8/20 (33%)]	Loss: 1.369758
Train Epoch: 2 [16/20 (67%)]	Loss: 1.307152

Test set: Avg. loss: 1.9619, Accuracy: 6021255/6599200 (91%)

New best! Saving...
Train Epoch: 3 [0/20 (0%)]	Loss: 1.272263
Train Epoch: 3 [8/20 (33%)]	Loss: 1.194274
Train Epoch: 3 [16/20 (67%)]	Loss: 0.920055

Test set: Avg. loss: 1.9092, Accuracy: 6021255/6599200 (91%)

New best! Saving...
Train Epoch: 4 [0/20 (0%)]	Loss: 1.018035
Train Epoch: 4 [8/20 (33%)]	Loss: 0.940074
Train Epoch: 4 [16/20 (67%)]	Loss: 0.842104

Test set: Avg. loss: 1.9849, Accuracy: 6021255/6599200 (91%)

Train Epoch: 5 [0/20 (0%)]	Loss: 0.837273
Train Epoch: 5 [8/20 (33%)]	Loss: 0.992546
Train Epoch: 5 [16/20 (67%)]	Loss: 0.789411

Test set: Avg. loss: 2.0387, Accuracy: 6021255/6599200 (91%)

Train Epoch: 6 [0/20 (0%)]	Loss: 0.840231
Train Epoch: 6 [8/20 (33%)]	Loss: 0.943322
Train Epoch: 6 [16/20 (67%)]	Loss: 0.873625

Test set: Avg. loss: 2.0668, Accuracy: 6021255/6599200 (91%)

Train Epoch: 7 [0/20 (0%)]	Loss: 0.831783
Train Epoch: 7 [8/20 (33%)]	Loss: 0.833295
Train Epoch: 7 [16/20 (67%)]	Loss: 0.954288

Test set: Avg. loss: 1.9886, Accuracy: 6021255/6599200 (91%)

Train Epoch: 8 [0/20 (0%)]	Loss: 0.816984
Train Epoch: 8 [8/20 (33%)]	Loss: 0.853048
Train Epoch: 8 [16/20 (67%)]	Loss: 0.911765

Test set: Avg. loss: 2.0919, Accuracy: 6021255/6599200 (91%)

Train Epoch: 9 [0/20 (0%)]	Loss: 0.805674
Train Epoch: 9 [8/20 (33%)]	Loss: 0.846167
Train Epoch: 9 [16/20 (67%)]	Loss: 0.855514

Test set: Avg. loss: 2.0332, Accuracy: 6021259/6599200 (91%)

network.load_state_dict(torch.load(parameters_file))
fig = plt.figure()
length=5
begin=0
visualization_range = np.random.choice(len(test_data), length)
example_data = torch.stack([test_data[i][0] for i in visualization_range])
example_targets = torch.stack([test_data[i][1] for i in visualization_range])
network.eval()
plt.figure(figsize=(3*5, length*5))
for i in range(length):
  print(example_data[i].shape)

  data = example_data[i].movedim(0, 2)

  print(data.shape)
  plt.subplot(length,3,3*i+1)
  plt.tight_layout()
  plt.imshow(data)
  plt.xticks([])
  plt.yticks([])
  target = example_targets[i]

  print (target.shape)
  plt.subplot(length,3,3*i+2)
  plt.tight_layout()
  plt.imshow(target, cmap='gray')
  plt.xticks([])
  plt.yticks([])

  print(torch.unique(target))
  with torch.no_grad():
    output = network(example_data[i].to(device).unsqueeze(0)).squeeze(0)
    print (output.shape)
    plt.subplot(length,3,3*i+3)
    plt.tight_layout()
    plt.imshow(output.cpu().argmax(-3) , cmap='gray')
    plt.xticks([])
    plt.yticks([])

torch.Size([3, 584, 565])
torch.Size([584, 565, 3])
torch.Size([584, 565])
tensor([0, 1])
torch.Size([2, 584, 565])
torch.Size([3, 584, 565])
torch.Size([584, 565, 3])
torch.Size([584, 565])
tensor([0, 1])
torch.Size([2, 584, 565])
torch.Size([3, 584, 565])
torch.Size([584, 565, 3])
torch.Size([584, 565])
tensor([0, 1])
torch.Size([2, 584, 565])
torch.Size([3, 584, 565])
torch.Size([584, 565, 3])
torch.Size([584, 565])
tensor([0, 1])
torch.Size([2, 584, 565])
torch.Size([3, 584, 565])
torch.Size([584, 565, 3])
torch.Size([584, 565])
tensor([0, 1])
torch.Size([2, 584, 565])

<Figure size 640x480 with 0 Axes>

(train_counter, train_losses, test_losses) = torch.load( training_data_file)
fig = plt.figure()
test_counter = [i*len(train_loader.dataset) for i in range(len(test_losses))]
for i in range(len(train_losses)):
  train_losses[i] = train_losses[i].cpu().detach()

for i in range(len(test_losses)):
  test_losses[i] = test_losses[i].cpu().detach()

plt.plot(train_counter, train_losses, color='blue', label='Treinamento')
plt.plot(test_counter, test_losses, color='red', label='Teste')
plt.legend(['Train Loss', 'Test Loss'], loc='upper right')
plt.xlabel('number of training examples seen')
plt.ylabel('cross-entropy loss')
plt.legend()
plt.title("Rede convolucional")

print(f"Best: {min(test_losses)}")

Best: 0.6804683804512024

gc.collect()
torch.cuda.empty_cache()

class UNetBlock(nn.Module):

  def __init__(self, in_channels, out_channels):
    super().__init__()

    self.seq=nn.Sequential(
      nn.Conv2d(in_channels, out_channels, 3, padding='same'),
      nn.ReLU(),
      nn.BatchNorm2d(out_channels),
      nn.Conv2d(out_channels, out_channels, 3, padding='same'),
      nn.ReLU())

  def forward(self, x):
    return self.seq(x)

class UpConvBlock(nn.Module):
  def __init__(self, in_channels, out_channels):
    super().__init__()

    self.ct= nn.Sequential(
      nn.ConvTranspose2d(in_channels, out_channels, kernel_size=2, stride=2),
      nn.ReLU())


  def forward(self, x, i):
    o = self.ct(x)

    padding = [0, 0, 0, 0]
    if o.shape[-1] == (i.shape[-1] - 1):
      padding[0] = 1
    if o.shape[-2] == (i.shape[-2] - 1):
      padding[2] = 1

    o = torch.nn.functional.pad(o, padding, mode='replicate')

    return torch.cat([i, o], dim=1)

class UNetGiga(nn.Module):
    def __init__(self):
        super().__init__()


        self.e1=UNetBlock(3, 64)
        self.me1=nn.MaxPool2d(2)

        self.e2=UNetBlock(64, 128)
        self.me2=nn.MaxPool2d(2)

        self.e3=UNetBlock(128, 256)
        self.me3=nn.MaxPool2d(2)


        self.bt=UNetBlock(256, 512)


        self.ct3=UpConvBlock(512, 256)
        self.d3=UNetBlock(512, 256)

        self.ct2=UpConvBlock(256, 128)
        self.d2=UNetBlock(256, 128)

        self.ct1=UpConvBlock(128, 64)
        self.d1=UNetBlock(128, 64)

        self.cls = nn.Sequential(
            nn.Conv2d(64, 2, kernel_size=1),
            nn.ReLU()
        )



    def forward(self, x):
        i1 = self.e1(x)
        i2 = self.e2(self.me1(i1))
        i3 = self.e3(self.me2(i2))

        b = self.bt(self.me3(i3))

        o3 = self.d3( self.ct3(b, i3) )
        o2 = self.d2( self.ct2(o3, i2) )
        o1 = self.d1( self.ct1(o2, i1) )

        cls = self.cls(o1)

        return cls

random_seed = 42
torch.manual_seed(random_seed)
device = 'cuda' if torch.cuda.is_available() else 'cpu'
parameters_file='/content/drive/MyDrive/modelos/segmentacao_vasos/parameters_giga.pth'
saved_parameters_file='/content/drive/MyDrive/modelos/segmentacao_vasos/best_parameters_giga.pth'
training_data_file='/content/drive/MyDrive/modelos/segmentacao_vasos/treinamento_giga.pickle'
batch_size_train = 2
batch_size_test = 2
train_loader = torch.utils.data.DataLoader(
  train_data,
  batch_size=batch_size_train, shuffle=True)

test_loader = torch.utils.data.DataLoader(
  test_data,
  batch_size=batch_size_test, shuffle=True)
device

'cuda'

gc.collect()
torch.cuda.empty_cache()
n_epochs = 150

learning_rate = 1e-3

log_interval=1

network = UNetGiga().to(device)

optimizer = optim.Adam(network.parameters(), lr=learning_rate)
loss_fn=nn.CrossEntropyLoss(reduction='none', )
scheduler = schd.StepLR(optimizer, 100, 0.5)

train_losses = []
train_counter = []
test_losses = []
test_counter=[]

count_parameters(network)

7700226

test(network, test_loader, loss_fn, batch_size_test,  test_losses, test_counter)
best=test_losses[-1]
for epoch in range(1, n_epochs + 1):
  train(network, train_loader, epoch, optimizer, loss_fn, log_interval, batch_size_train, train_losses, train_counter)
  test(network, test_loader, loss_fn, batch_size_test,  test_losses, test_counter)
  if test_losses[-1] < best:
    best=test_losses[-1]
    print("New best! Saving...")
    torch.save(network.state_dict(), parameters_file)
  scheduler.step()

torch.save((train_counter, train_losses, test_losses), training_data_file)

Test set: Avg. loss: 2.0398, Accuracy: 6021255/6599200 (91%)

Train Epoch: 1 [0/20 (0%)]	Loss: 2.105670
Train Epoch: 1 [2/20 (10%)]	Loss: 2.164086
Train Epoch: 1 [4/20 (20%)]	Loss: 2.061682
Train Epoch: 1 [6/20 (30%)]	Loss: 1.669649
Train Epoch: 1 [8/20 (40%)]	Loss: 1.646256
Train Epoch: 1 [10/20 (50%)]	Loss: 1.772807
Train Epoch: 1 [12/20 (60%)]	Loss: 1.629969
Train Epoch: 1 [14/20 (70%)]	Loss: 1.567791
Train Epoch: 1 [16/20 (80%)]	Loss: 1.454288
Train Epoch: 1 [18/20 (90%)]	Loss: 1.657349

Test set: Avg. loss: 1.9200, Accuracy: 6021255/6599200 (91%)

New best! Saving...
Train Epoch: 2 [0/20 (0%)]	Loss: 1.470815
Train Epoch: 2 [2/20 (10%)]	Loss: 1.385474
Train Epoch: 2 [4/20 (20%)]	Loss: 1.250381
Train Epoch: 2 [6/20 (30%)]	Loss: 1.499206
Train Epoch: 2 [8/20 (40%)]	Loss: 1.243076
Train Epoch: 2 [10/20 (50%)]	Loss: 1.090109
Train Epoch: 2 [12/20 (60%)]	Loss: 1.122425
Train Epoch: 2 [14/20 (70%)]	Loss: 1.343699
Train Epoch: 2 [16/20 (80%)]	Loss: 1.163055
Train Epoch: 2 [18/20 (90%)]	Loss: 1.126568

Test set: Avg. loss: 2.3176, Accuracy: 6021255/6599200 (91%)

Train Epoch: 3 [0/20 (0%)]	Loss: 1.083523
Train Epoch: 3 [2/20 (10%)]	Loss: 1.038503
Train Epoch: 3 [4/20 (20%)]	Loss: 1.163005
Train Epoch: 3 [6/20 (30%)]	Loss: 1.296006
Train Epoch: 3 [8/20 (40%)]	Loss: 1.140650
Train Epoch: 3 [10/20 (50%)]	Loss: 0.961986
Train Epoch: 3 [12/20 (60%)]	Loss: 1.146081
Train Epoch: 3 [14/20 (70%)]	Loss: 1.275786
Train Epoch: 3 [16/20 (80%)]	Loss: 1.015369
Train Epoch: 3 [18/20 (90%)]	Loss: 1.069251

Test set: Avg. loss: 2.8096, Accuracy: 6021131/6599200 (91%)

Train Epoch: 4 [0/20 (0%)]	Loss: 1.154545
Train Epoch: 4 [2/20 (10%)]	Loss: 1.008595
Train Epoch: 4 [4/20 (20%)]	Loss: 1.130684
Train Epoch: 4 [6/20 (30%)]	Loss: 0.993621
Train Epoch: 4 [8/20 (40%)]	Loss: 1.076076
Train Epoch: 4 [10/20 (50%)]	Loss: 1.014167
Train Epoch: 4 [12/20 (60%)]	Loss: 1.061702
Train Epoch: 4 [14/20 (70%)]	Loss: 0.922724
Train Epoch: 4 [16/20 (80%)]	Loss: 1.182678
Train Epoch: 4 [18/20 (90%)]	Loss: 1.052276

Test set: Avg. loss: 2.9627, Accuracy: 6029738/6599200 (91%)

Train Epoch: 5 [0/20 (0%)]	Loss: 0.917081
Train Epoch: 5 [2/20 (10%)]	Loss: 1.058229
Train Epoch: 5 [4/20 (20%)]	Loss: 1.103771
Train Epoch: 5 [6/20 (30%)]	Loss: 1.074641
Train Epoch: 5 [8/20 (40%)]	Loss: 1.037003
Train Epoch: 5 [10/20 (50%)]	Loss: 1.050065
Train Epoch: 5 [12/20 (60%)]	Loss: 1.004286
Train Epoch: 5 [14/20 (70%)]	Loss: 1.013961
Train Epoch: 5 [16/20 (80%)]	Loss: 0.976543
Train Epoch: 5 [18/20 (90%)]	Loss: 1.237423

Test set: Avg. loss: 1.4697, Accuracy: 6225487/6599200 (94%)

New best! Saving...
Train Epoch: 6 [0/20 (0%)]	Loss: 0.984397
Train Epoch: 6 [2/20 (10%)]	Loss: 0.929395
Train Epoch: 6 [4/20 (20%)]	Loss: 0.984386
Train Epoch: 6 [6/20 (30%)]	Loss: 1.128022
Train Epoch: 6 [8/20 (40%)]	Loss: 0.991531
Train Epoch: 6 [10/20 (50%)]	Loss: 1.018470
Train Epoch: 6 [12/20 (60%)]	Loss: 0.947866
Train Epoch: 6 [14/20 (70%)]	Loss: 1.225986
Train Epoch: 6 [16/20 (80%)]	Loss: 0.930891
Train Epoch: 6 [18/20 (90%)]	Loss: 1.020034

Test set: Avg. loss: 1.4405, Accuracy: 6256997/6599200 (95%)

New best! Saving...
Train Epoch: 7 [0/20 (0%)]	Loss: 0.922008
Train Epoch: 7 [2/20 (10%)]	Loss: 1.002270
Train Epoch: 7 [4/20 (20%)]	Loss: 1.171082
Train Epoch: 7 [6/20 (30%)]	Loss: 0.858109
Train Epoch: 7 [8/20 (40%)]	Loss: 1.063837
Train Epoch: 7 [10/20 (50%)]	Loss: 0.985177
Train Epoch: 7 [12/20 (60%)]	Loss: 1.017859
Train Epoch: 7 [14/20 (70%)]	Loss: 0.908284
Train Epoch: 7 [16/20 (80%)]	Loss: 1.073130
Train Epoch: 7 [18/20 (90%)]	Loss: 0.987205

Test set: Avg. loss: 1.3621, Accuracy: 6266322/6599200 (95%)

New best! Saving...
Train Epoch: 8 [0/20 (0%)]	Loss: 0.890569
Train Epoch: 8 [2/20 (10%)]	Loss: 1.145118
Train Epoch: 8 [4/20 (20%)]	Loss: 1.108971
Train Epoch: 8 [6/20 (30%)]	Loss: 0.932407
Train Epoch: 8 [8/20 (40%)]	Loss: 1.011481
Train Epoch: 8 [10/20 (50%)]	Loss: 0.880817
Train Epoch: 8 [12/20 (60%)]	Loss: 0.957791
Train Epoch: 8 [14/20 (70%)]	Loss: 0.881122
Train Epoch: 8 [16/20 (80%)]	Loss: 0.903741
Train Epoch: 8 [18/20 (90%)]	Loss: 1.105094

Test set: Avg. loss: 1.0789, Accuracy: 6348191/6599200 (96%)

New best! Saving...
Train Epoch: 9 [0/20 (0%)]	Loss: 0.812276
Train Epoch: 9 [2/20 (10%)]	Loss: 0.949030
Train Epoch: 9 [4/20 (20%)]	Loss: 0.847686
Train Epoch: 9 [6/20 (30%)]	Loss: 0.904761
Train Epoch: 9 [8/20 (40%)]	Loss: 0.922625
Train Epoch: 9 [10/20 (50%)]	Loss: 1.010980
Train Epoch: 9 [12/20 (60%)]	Loss: 1.055115
Train Epoch: 9 [14/20 (70%)]	Loss: 1.191017
Train Epoch: 9 [16/20 (80%)]	Loss: 0.917542
Train Epoch: 9 [18/20 (90%)]	Loss: 0.994404

Test set: Avg. loss: 0.9846, Accuracy: 6339222/6599200 (96%)

fig = plt.figure()
(train_counter, train_losses, test_losses) = torch.load( training_data_file)

test_counter = [i*len(train_loader.dataset) for i in range(len(test_losses))]
for i in range(len(train_losses)):
  train_losses[i] = train_losses[i].cpu().detach()

for i in range(len(test_losses)):
  test_losses[i] = test_losses[i].cpu().detach()

plt.plot(train_counter, train_losses, color='blue', label='Treinamento')
plt.plot(test_counter, test_losses, color='red', label='Teste')
plt.legend(['Train Loss', 'Test Loss'], loc='upper right')
plt.xlabel('number of training examples seen')
plt.ylabel('cross-entropy loss')
plt.legend()
plt.title("Rede convolucional")

print(f"Best: {min(test_losses)}")

Best: 0.6731995940208435

network.load_state_dict(torch.load(parameters_file))
fig = plt.figure()
length=5
begin=0
visualization_range = np.random.choice(len(test_data), length)
example_data = torch.stack([test_data[i][0] for i in visualization_range])
example_targets = torch.stack([test_data[i][1] for i in visualization_range])
network.eval()
plt.figure(figsize=(3*5, length*5))
for i in range(length):
  print(example_data[i].shape)

  data = example_data[i].movedim(0, 2)

  print(data.shape)
  plt.subplot(length,3,3*i+1)
  plt.tight_layout()
  plt.imshow(data)
  plt.xticks([])
  plt.yticks([])
  target = example_targets[i]

  print (target.shape)
  plt.subplot(length,3,3*i+2)
  plt.tight_layout()
  plt.imshow(target, cmap='gray')
  plt.xticks([])
  plt.yticks([])

  print(torch.unique(target))
  with torch.no_grad():
    output = network(example_data[i].to(device).unsqueeze(0)).squeeze(0)
    print (output.shape)
    plt.subplot(length,3,3*i+3)
    plt.tight_layout()
    plt.imshow(output.cpu().argmax(-3) , cmap='gray')
    plt.xticks([])
    plt.yticks([])

torch.Size([3, 584, 565])
torch.Size([584, 565, 3])
torch.Size([584, 565])
tensor([0, 1])
torch.Size([2, 584, 565])
torch.Size([3, 584, 565])
torch.Size([584, 565, 3])
torch.Size([584, 565])
tensor([0, 1])
torch.Size([2, 584, 565])
torch.Size([3, 584, 565])
torch.Size([584, 565, 3])
torch.Size([584, 565])
tensor([0, 1])
torch.Size([2, 584, 565])
torch.Size([3, 584, 565])
torch.Size([584, 565, 3])
torch.Size([584, 565])
tensor([0, 1])
torch.Size([2, 584, 565])
torch.Size([3, 584, 565])
torch.Size([584, 565, 3])
torch.Size([584, 565])
tensor([0, 1])
torch.Size([2, 584, 565])

<Figure size 640x480 with 0 Axes>

Exploração dos dados¶

Rede menor¶

Versão maior¶